home *** CD-ROM | disk | FTP | other *** search
/ Nebula 1 / Nebula One.iso / Graphics / Multimedia / Movie3.0 / Source / xanim / xanim_rle.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-06-02  |  15.0 KB  |  558 lines
  1.  
  2. /*
  3.  * xanim_rle.c
  4.  *
  5.  * Copyright (C) 1993,1994 by Mark Podlipec. 
  6.  * All rights reserved.
  7.  *
  8.  * This software may be freely copied, modified and redistributed without
  9.  * fee for non-commerical purposes provided that this copyright notice is
  10.  * preserved intact on all copies and modified copies.
  11.  * 
  12.  * There is no warranty or other guarantee of fitness of this software.
  13.  * It is provided solely "as is". The author(s) disclaim(s) all
  14.  * responsibility and liability with respect to this software's usage
  15.  * or its effect upon hardware or computer systems.
  16.  *
  17.  */
  18. #include "xanim_rle.h"
  19.  
  20. LONG Is_RLE_File();
  21. ULONG RLE_Read_File();
  22. ULONG RLE_Read_Header();
  23. ULONG RLE_Get_Image();
  24. void RLE_Read_Row();
  25.  
  26. XA_ACTION *ACT_Get_Action();
  27. XA_CHDR   *ACT_Get_CMAP();
  28. XA_CHDR *CMAP_Create_332();
  29. XA_CHDR *CMAP_Create_Gray();
  30. XA_CHDR *CMAP_Create_CHDR_From_True();
  31. UBYTE *UTIL_RGB_To_Map();
  32. UBYTE *UTIL_RGB_To_FS_Map();
  33. ULONG UTIL_Get_LSB_Short();
  34. void ACT_Setup_Mapped();
  35. void ACT_Add_CHDR_To_Action();
  36.  
  37. ULONG rle_imagex, rle_imagey, rle_imagec;
  38. ULONG rle_max_imagex, rle_max_imagey;
  39. ULONG rle_xpos,rle_ypos;
  40. ULONG rle_image_size;
  41. ColorReg rle_cmap[256];
  42. UBYTE bg_color[3];
  43. UBYTE rle_chan_map[3][256];
  44. XA_CHDR *rle_chdr;
  45. UBYTE *rle_pic;
  46.  
  47. static RLE_FRAME *rle_frame_start,*rle_frame_cur;
  48. static ULONG rle_frame_cnt;
  49. static RLE_HDR rle_hdr;
  50. static LONG priv_vert_skip;
  51. static LONG priv_scan_y;
  52. static LONG priv_is_eof;
  53. static UBYTE *rle_row_buf,*rle_rows[3];
  54.  
  55. /*
  56.  *
  57.  */
  58. LONG Is_RLE_File(filename)
  59. char *filename;
  60. {
  61.   FILE *fin;
  62.   ULONG data;
  63.  
  64.   if ( (fin=fopen(filename,XA_OPEN_MODE)) == 0) return(XA_NOFILE);
  65.   data = UTIL_Get_LSB_Short(fin);  /* read past size */
  66.   fclose(fin);
  67.   if (data == RLE_MAGIC) return(TRUE);
  68.   return(FALSE);
  69. }
  70.  
  71.  
  72. RLE_FRAME *RLE_Add_Frame(time,act)
  73. ULONG time;
  74. XA_ACTION *act;
  75. {
  76.   RLE_FRAME *rframe;
  77.  
  78.   rframe = (RLE_FRAME *) malloc(sizeof(RLE_FRAME));
  79.   if (rframe == 0) TheEnd1("RLE_Add_Frame: malloc err");
  80.  
  81.   rframe->time = time;
  82.   rframe->act = act;
  83.   rframe->next = 0;
  84.  
  85.   if (rle_frame_start == 0) rle_frame_start = rframe;
  86.   else rle_frame_cur->next = rframe;
  87.  
  88.   rle_frame_cur = rframe;
  89.   rle_frame_cnt++;
  90.   return(rframe);
  91. }
  92.  
  93. void
  94. RLE_Free_Frame_List(rframes)
  95. RLE_FRAME *rframes;
  96. {
  97.   RLE_FRAME *rtmp;
  98.   while(rframes != 0)
  99.   {
  100.     rtmp = rframes;
  101.     rframes = rframes->next;
  102.     FREE(rtmp,0x9999);
  103.   }
  104. }
  105.  
  106.  
  107. ULONG RLE_Read_File(fname,anim_hdr)
  108. char *fname;
  109. XA_ANIM_HDR *anim_hdr;
  110. {
  111.   int i;
  112.   RLE_FRAME *rtmp;
  113.  
  114.  
  115.   rle_frame_start = 0;
  116.   rle_frame_cur = 0;
  117.   rle_frame_cnt = 0;
  118.   rle_imagex = rle_imagey = 0;
  119.   rle_max_imagex = rle_max_imagey = 0;
  120.   rle_imagec = 0;
  121.  
  122.   rle_chdr = 0;
  123.  
  124.   if (RLE_Get_Image(fname,anim_hdr)==FALSE) return(FALSE);
  125.  
  126.     anim_hdr->frame_lst = (XA_FRAME *)
  127.         malloc(sizeof(XA_FRAME) * (rle_frame_cnt + 1));
  128.   if (anim_hdr->frame_lst == NULL)
  129.        TheEnd1("RLE_Read_Anim: malloc err");
  130.  
  131.   rtmp = rle_frame_start;
  132.   i = 0;
  133.   while(rtmp != 0)
  134.   {
  135.     if (i >= rle_frame_cnt)
  136.     {
  137.       fprintf(stderr,"RLE_Read_Anim: frame inconsistency %ld %ld\n",
  138.                 i,rle_frame_cnt);
  139.       break;
  140.     }
  141.     anim_hdr->frame_lst[i].time = rtmp->time;
  142.     anim_hdr->frame_lst[i].act = rtmp->act;
  143.     rtmp = rtmp->next;
  144.     i++;
  145.   }
  146.   anim_hdr->frame_lst[i].time = 0;
  147.   anim_hdr->frame_lst[i].act  = 0;
  148.   anim_hdr->loop_frame = 0;
  149.   if (i > 0) anim_hdr->last_frame = i - 1;
  150.   else i = 0;
  151.   anim_hdr->imagex = rle_max_imagex;
  152.   anim_hdr->imagey = rle_max_imagey;
  153.   anim_hdr->imagec = rle_imagec;
  154.   anim_hdr->imaged = 8;
  155.  
  156.   RLE_Free_Frame_List(rle_frame_start);
  157.   return(TRUE);
  158. } 
  159.  
  160. ULONG 
  161. RLE_Read_Header(fp,rle_hdr)
  162. FILE *fp;
  163. RLE_HDR *rle_hdr;
  164. {
  165.   rle_hdr->magic  = UTIL_Get_LSB_Short(fp);
  166.   if (rle_hdr->magic != RLE_MAGIC) return(FALSE);
  167.  
  168.   rle_hdr->xpos  = UTIL_Get_LSB_Short(fp);
  169.   rle_hdr->ypos  = UTIL_Get_LSB_Short(fp);
  170.   rle_hdr->xsize = UTIL_Get_LSB_Short(fp);
  171.   rle_hdr->ysize = UTIL_Get_LSB_Short(fp);
  172.  
  173.   rle_hdr->flags     = (ULONG)getc(fp) & 0xff;
  174.   rle_hdr->chan_num  = (ULONG)getc(fp) & 0xff;
  175.   rle_hdr->pbits     = (ULONG)getc(fp) & 0xff;
  176.   rle_hdr->cmap_num  = (ULONG)getc(fp) & 0xff;
  177.   rle_hdr->cbits     = getc(fp) & 0xff;
  178.   if (rle_hdr->cbits > 8) TheEnd1("RLE_Read_Header: csize > 256\n");
  179.   if (rle_hdr->cbits == 0) rle_hdr->cbits = rle_hdr->pbits; /*PODGUESS*/
  180.   rle_hdr->csize     =  0x01 << rle_hdr->cbits;
  181.  
  182.   DEBUG_LEVEL1
  183.   {
  184.     fprintf(stderr,"RLE_Read_Header: pos %ld %ld size %ld %ld csize %ld\n",
  185.         rle_hdr->xpos,rle_hdr->ypos,rle_hdr->xsize,rle_hdr->ysize,
  186.         rle_hdr->csize);
  187.     fprintf(stderr,"                 flags %lx chans %ld pbits %ld maps %ld\n",
  188.     rle_hdr->flags,rle_hdr->chan_num,rle_hdr->pbits,rle_hdr->cmap_num);
  189.   }
  190.  
  191.   /* read background colors - only save 1st three */
  192.   if ( !(rle_hdr->flags & RLEH_NO_BACKGROUND) )
  193.   {
  194.     register ULONG i,j;
  195.     j = 1 + (rle_hdr->chan_num / 2) * 2;
  196.     for(i=0; i < j; i++)
  197.     { 
  198.       if (i < 3) bg_color[i] = getc(fp) & 0xff;
  199.       else (void)getc(fp);
  200.     }
  201.   }
  202.   else 
  203.   {
  204.     bg_color[0] = bg_color[1] = bg_color[2] = 0; 
  205.     (void)getc(fp);
  206.   }
  207.  
  208.   /* read all of the color maps - only store 1st three */
  209.   if (rle_hdr->cmap_num)
  210.   {
  211.     register ULONG i,j,d;
  212.     for(i=0; i < rle_hdr->cmap_num; i++)
  213.     {
  214.       for(j=0; j < rle_hdr->csize; j++)
  215.       {
  216.         d = UTIL_Get_LSB_Short(fp);
  217.         if (i < 3) rle_chan_map[i][j] = d >> 8;
  218.       }
  219.     }
  220.     if (rle_hdr->cmap_num == 1) /* singlemap? copy to others */
  221.     {
  222.       for(j=0; j < rle_hdr->csize; j++)
  223.         rle_chan_map[1][j] = rle_chan_map[2][j] = rle_chan_map[0][j];
  224.     } 
  225.   }
  226.   else  /* no maps? then create linear maps */
  227.   { register ULONG i;
  228.     for(i=0;i<rle_hdr->csize;i++) 
  229.     rle_chan_map[0][i] = rle_chan_map[1][i] = rle_chan_map[2][i] = i;
  230.   }
  231.   /* GAMMA adjust map */
  232.   if (   (rle_hdr->chan_num == 3) && (cmap_true_map_flag == TRUE)
  233.       && (xa_gamma_flag==TRUE) )  
  234.   { register ULONG i,j;
  235.     for(j=0;j<3;j++)
  236.       for(i=0;i<rle_hdr->csize;i++)
  237.     rle_chan_map[j][i] = xa_gamma_adj[ rle_chan_map[j][i] ] >> 8;
  238.   }
  239.  
  240.   /* skip comments */
  241.   if (rle_hdr->flags & RLEH_COMMENT)  /* see rle_retrow.c for more details */
  242.   {
  243.     register ULONG d,i,len;
  244.     len = UTIL_Get_LSB_Short(fp);
  245.     for(i=0; i<len; i++)
  246.     {
  247.       d = getc(fp) & 0xff;
  248.     /* if (xa_verbose) fprintf(stderr,"%c",d); */
  249.     }
  250.     if (len & 0x01) getc(fp); /* pad */
  251.   }
  252.  
  253.   /*  if not end of file return ok */
  254.   if ( !feof(fp) )
  255.   {
  256.     rle_imagec = rle_hdr->csize;
  257.     rle_imagex = rle_hdr->xsize;
  258.     rle_imagey = rle_hdr->ysize;
  259.     if (rle_imagex > rle_max_imagex) rle_max_imagex = rle_imagex;
  260.     if (rle_imagey > rle_max_imagey) rle_max_imagey = rle_imagey;
  261.     rle_xpos   = rle_hdr->xpos;
  262.     rle_ypos   = rle_max_imagey - (rle_hdr->ypos + rle_hdr->ysize);
  263.     rle_image_size = rle_imagex * rle_imagey;
  264.      /* POD need to check for initial image having non zero pos and need to
  265.       * check for subsequent images fitting in initial images
  266.       * maybe keep initial positions around to shift subsequent.
  267.       */
  268.     priv_scan_y = rle_hdr->ypos;
  269.     priv_vert_skip = 0;
  270.     priv_is_eof = FALSE;
  271.  
  272.     return(TRUE);
  273.   } else return(False);
  274. }
  275.  
  276.  
  277. ULONG RLE_Get_Image(filename,anim_hdr)
  278. char *filename;
  279. XA_ANIM_HDR *anim_hdr;
  280. {
  281.   XA_ACTION *act;
  282.   FILE *fin;
  283.   int x,y;
  284.   int rle_cnt;
  285.   UBYTE *im_ptr;
  286.  
  287.   if ( (fin=fopen(filename,XA_OPEN_MODE)) == 0)
  288.   {
  289.     fprintf(stderr,"can't open RLE File %s for reading\n",filename);
  290.     return(FALSE);
  291.   }
  292.  
  293.   rle_cnt = 0;
  294.   while ( RLE_Read_Header(fin,&rle_hdr) == TRUE )
  295.   {
  296.     rle_cnt++;
  297.  
  298.     if ( (rle_hdr.chan_num != 1) && (rle_hdr.chan_num != 3) )
  299.             TheEnd1("RLE_Get_Image: only 1 and 3 channels supported");
  300.     /* currently must do this here to init xa_r_mask, etc TBD*/
  301.     if (  (rle_hdr.chan_num == 3) && (cmap_true_map_flag != TRUE)
  302.     && (rle_chdr == 0) )
  303.     {
  304.     if (cmap_true_to_332 == TRUE)
  305.         rle_chdr = CMAP_Create_332(rle_cmap,&rle_imagec);
  306.     else    rle_chdr = CMAP_Create_Gray(rle_cmap,&rle_imagec);
  307.     }
  308.  
  309.     if (xa_verbose) fprintf(stderr,"%ld) pos %ld %ld  size %ld %ld chans %ld\n",
  310.       rle_cnt,rle_xpos,rle_ypos,rle_imagex,rle_imagey,rle_hdr.chan_num);
  311.  
  312.     /* Allocate memory for the input image. */
  313.     if (rle_cnt == 1) 
  314.     {
  315.       ULONG i,num_to_alloc;
  316.       UBYTE *p;
  317.       if (x11_display_type & XA_X11_TRUE) num_to_alloc = 3;
  318.       else num_to_alloc = rle_hdr.chan_num;
  319.       p = rle_row_buf = (UBYTE *)malloc( num_to_alloc * rle_imagex );
  320.       if (rle_row_buf == 0) TheEnd1("RLE rowbuf malloc err");
  321.       for(i=0; i<num_to_alloc; i++) { rle_rows[i] = p; p += rle_imagex; };
  322.     }
  323.     if (    (cmap_true_map_flag == TRUE) && (rle_hdr.chan_num == 3)
  324.         && !(x11_display_type & XA_X11_TRUE) )
  325.         rle_pic = (UBYTE *)malloc( 3 * rle_image_size );
  326.     else    rle_pic = (UBYTE *)malloc( XA_PIC_SIZE(rle_image_size) );
  327.     if (rle_pic == 0) TheEnd1("RLE_Get_Image: malloc err\n");
  328.  
  329.     im_ptr = rle_pic;
  330.     y = rle_imagey; while(y--)
  331.     {
  332.       RLE_Read_Row(fin,&rle_hdr);
  333.  
  334.       /* if three channel image then remap data with rle_chan_map */
  335.       if (rle_hdr.chan_num == 3)
  336.       {
  337.     register int i; register UBYTE *p0,*p1,*p2;
  338.     i = rle_imagex; p0 = rle_rows[0]; p1 = rle_rows[1]; p2 = rle_rows[2];
  339.     while(i--) 
  340.     { 
  341.       *p0++ = rle_chan_map[RLE_RED][(ULONG)(*p0)];
  342.       *p1++ = rle_chan_map[RLE_GREEN][(ULONG)(*p1)]; 
  343.       *p2++ = rle_chan_map[RLE_BLUE][(ULONG)(*p2)]; 
  344.     }
  345.       }
  346.  
  347.       if (x11_display_type & XA_X11_TRUE)
  348.       {
  349.     register int i; register UBYTE *p0,*p1,*p2;
  350.  
  351.     /* expand to rgb if color mapped image */
  352.     if (rle_hdr.chan_num == 1)
  353.     {
  354.       i = rle_imagex; p0 = rle_rows[0]; p1 = rle_rows[1]; p2 = rle_rows[2];
  355.       while(i--)
  356.       { register ULONG d = (ULONG)(*p0);
  357.         *p0++ = rle_chan_map[RLE_RED][d];
  358.         *p1++ = rle_chan_map[RLE_GREEN][d];
  359.         *p2++ = rle_chan_map[RLE_BLUE][d];
  360.       }
  361.     }
  362.  
  363.     i = rle_imagex; p0 = rle_rows[0]; p1 = rle_rows[1]; p2 = rle_rows[2];
  364.         if (x11_bytes_pixel == 1)
  365.         {
  366.           UBYTE *iptr = (UBYTE *)(rle_pic + (y * rle_imagex));
  367.       while(i--) *iptr++ = (UBYTE)
  368.         X11_Get_True_Color((ULONG)(*p0++),(ULONG)(*p1++),(ULONG)(*p2++),8);
  369.     }
  370.         else if (x11_bytes_pixel == 2)
  371.         {
  372.           USHORT *iptr = (USHORT *)(rle_pic + (2 * y * rle_imagex));
  373.       while(i--) *iptr++ = (USHORT)
  374.         X11_Get_True_Color((ULONG)(*p0++),(ULONG)(*p1++),(ULONG)(*p2++),8);
  375.     }
  376.         else
  377.         {
  378.           ULONG *iptr = (ULONG *)(rle_pic + (4 * y * rle_imagex));
  379.       while(i--) *iptr++ = (ULONG)
  380.         X11_Get_True_Color((ULONG)(*p0++),(ULONG)(*p1++),(ULONG)(*p2++),8);
  381.     }
  382.       }
  383.       else if (rle_hdr.chan_num == 1) /* color mapped image */
  384.       {
  385.         im_ptr = (UBYTE *)(rle_pic + y * rle_imagex);
  386.         for(x=0; x < rle_imagex; x++) *im_ptr++ = (UBYTE)rle_rows[0][x];
  387.       }
  388.       else if (cmap_true_map_flag == TRUE) /* 3 channels */
  389.       {
  390.         im_ptr = (UBYTE *)(rle_pic + (3 * y * rle_imagex));
  391.         for(x=0; x < rle_imagex; x++)
  392.     {
  393.       *im_ptr++ = (UBYTE)rle_rows[0][x];
  394.       *im_ptr++ = (UBYTE)rle_rows[1][x];
  395.       *im_ptr++ = (UBYTE)rle_rows[2][x];
  396.     }
  397.       }
  398.       else
  399.       {
  400.         im_ptr =  (UBYTE *)( rle_pic + (y * rle_imagex));
  401.         if (cmap_true_to_332 == TRUE)
  402.     {
  403.           for(x=0; x < rle_imagex; x++)
  404.       {
  405.         *im_ptr++ = CMAP_GET_332( (ULONG)(rle_rows[0][x]),
  406.         (ULONG)(rle_rows[1][x]), (ULONG)(rle_rows[2][x]), CMAP_SCALE8 );
  407.       }
  408.     }
  409.         else 
  410.     {
  411.           for(x=0; x < rle_imagex; x++)
  412.       {
  413.         *im_ptr++ = CMAP_GET_GRAY( (ULONG)(rle_rows[0][x]),
  414.         (ULONG)(rle_rows[1][x]), (ULONG)(rle_rows[2][x]), CMAP_SCALE13 );
  415.       }
  416.     }
  417.       }
  418.     }
  419.  
  420.     act = ACT_Get_Action(anim_hdr);
  421.  
  422.     /* Create Color Maps */
  423.     if (rle_hdr.chan_num == 1) /* images with color maps */
  424.     { register ULONG i;
  425.       for(i=0; i<rle_imagec; i++)
  426.       {
  427.     rle_cmap[i].red   = rle_chan_map[RLE_RED][i];
  428.     rle_cmap[i].green = rle_chan_map[RLE_GREEN][i];
  429.     rle_cmap[i].blue  = rle_chan_map[RLE_BLUE][i];
  430.       }
  431.       rle_chdr = ACT_Get_CMAP(rle_cmap,rle_imagec,0,rle_imagec,0,8,8,8);
  432.     }
  433.     else if (cmap_true_map_flag == TRUE)  /* 3 channels */
  434.     {
  435.       UBYTE *tpic;
  436.  
  437.       if (    (cmap_true_to_all == TRUE)
  438.           || ((cmap_true_to_1st == TRUE) && (rle_chdr == 0) )
  439.          )        rle_chdr = CMAP_Create_CHDR_From_True(rle_pic,8,8,8,
  440.                 rle_imagex,rle_imagey,rle_cmap,&rle_imagec);
  441.       else if ( (cmap_true_to_332 == TRUE) && (rle_chdr == 0) )
  442.             rle_chdr = CMAP_Create_332(rle_cmap,&rle_imagec);
  443.       else if ( (cmap_true_to_gray == TRUE) && (rle_chdr == 0) )
  444.             rle_chdr = CMAP_Create_Gray(rle_cmap,&rle_imagec);
  445.  
  446.       if (cmap_dither_type == CMAP_DITHER_FLOYD)
  447.         tpic = UTIL_RGB_To_FS_Map(0,rle_pic,rle_chdr,
  448.                 rle_imagex,rle_imagey,TRUE);
  449.       else
  450.         tpic = UTIL_RGB_To_Map(0,rle_pic,rle_chdr,rle_imagex,rle_imagey,TRUE);
  451.       FREE(rle_pic,0x9999);
  452.       rle_pic = tpic;
  453.     } /* NOTE: 332 and Gray Cases are done much earlier */
  454.     else  /* 3 channels to either gray or 332 */
  455.     {
  456.       if (rle_chdr == 0)  /* error, this should have happened earlier */
  457.     TheEnd1("RLE_Read_File: 332/gray error");
  458.     }
  459.  
  460.     if (x11_display_type & XA_X11_TRUE)
  461.     { 
  462.       ACT_Setup_Mapped(act,rle_pic, 0,
  463.                      rle_xpos,rle_ypos,rle_imagex,rle_imagey,
  464.                      rle_imagex,rle_imagey,FALSE,0,TRUE,TRUE,TRUE);
  465.     }
  466.     else
  467.     { 
  468.       ACT_Setup_Mapped(act,rle_pic, rle_chdr,
  469.                      rle_xpos,rle_ypos,rle_imagex,rle_imagey,
  470.                      rle_imagex,rle_imagey,FALSE,0,TRUE,TRUE,FALSE);
  471.       ACT_Add_CHDR_To_Action(act,rle_chdr);
  472.     }
  473.     RLE_Add_Frame(17,act);
  474.  
  475.   }
  476.   if (rle_row_buf) { FREE(rle_row_buf,0x999); rle_row_buf=0; }
  477.   fclose(fin);
  478.   return(TRUE);
  479. }
  480.  
  481.  
  482. void RLE_Read_Row(fp,rle_hdr)
  483. FILE *fp;
  484. RLE_HDR *rle_hdr;
  485. {
  486.   ULONG posx,opcode,opdata,data;
  487.   ULONG ymax,channel,exit_flag;
  488.  
  489.   ymax = rle_ypos + rle_imagey;
  490.   posx = 0;
  491.   exit_flag = 0;
  492.  
  493.   /* clear to background if necessary */
  494.   if ( !(rle_hdr->flags & RLEH_NO_BACKGROUND) ) 
  495.   { register ULONG i;
  496.     for(i=0; i < rle_hdr->chan_num; i++)
  497.         memset( (char *)rle_rows[i], bg_color[i], rle_hdr->xsize);
  498.   }
  499.  
  500.   if (priv_vert_skip) 
  501.   {
  502.     priv_vert_skip--; 
  503.     DEBUG_LEVEL3 fprintf(stderr,"  Prev Skip %ld\n",priv_vert_skip);
  504.     return;
  505.   }
  506.   if ( priv_is_eof ) return;  /* EOF already encountered */
  507.  
  508.   while(!exit_flag)
  509.   {
  510.     opcode = getc(fp) & 0xff;
  511.     opdata = getc(fp) & 0xff;
  512.     switch( RLE_OPCODE(opcode) )
  513.     {
  514.       case RLE_SkipLinesOp:
  515.     if (RLE_LONGP(opcode))  priv_vert_skip = UTIL_Get_LSB_Short(fp); 
  516.         else priv_vert_skip = opdata;
  517.     priv_vert_skip--;  /* count this line */
  518.     posx = 0;
  519.         exit_flag = 1; 
  520.     break;
  521.       case RLE_SetColorOp:
  522.     channel = opdata; posx = 0;
  523.     break;
  524.       case RLE_SkipPixelsOp:
  525.     if (RLE_LONGP(opcode))  posx += UTIL_Get_LSB_Short(fp); 
  526.         else posx += opdata;
  527.     break;
  528.       case RLE_ByteDataOp:
  529.     { register ULONG i;
  530.     if (RLE_LONGP(opcode))  opdata = UTIL_Get_LSB_Short(fp); 
  531.     opdata++; i = opdata;
  532.         if (channel < 3)
  533.           while(i--) {rle_rows[channel][posx] = getc(fp); posx++;}
  534.     else    { posx += opdata; while(i--) (void)getc(fp); }
  535.     if (opdata & 0x01) (void)getc(fp);  /* pad to SHORT */
  536.     }
  537.     break;
  538.       case RLE_RunDataOp:
  539.     if (RLE_LONGP(opcode))  opdata = UTIL_Get_LSB_Short(fp); 
  540.     opdata++;
  541.     data = getc(fp) & 0xff;  (void)getc(fp);
  542.         if (channel < 3)
  543.         while(opdata--) {rle_rows[channel][posx] = data; posx++;}
  544.     else    posx += opdata;
  545.     break;
  546.       case RLE_EOFOp:
  547.     priv_is_eof = TRUE;
  548.     exit_flag = 1;
  549.     break;
  550.       default:
  551.     fprintf(stderr,"RLE unknown opcode %lx\n",RLE_OPCODE(opcode));
  552.     exit_flag = 1;
  553.     } /* end of opcode switch */
  554.   } /* end of while */
  555. }
  556.        
  557.  
  558.